/*************************************************************************
                         Collection  -  interface
                             -------------------
    debut                : 10 oct. 2009
    copyright            : (C) 2009 par Binome 3310
*************************************************************************/

//------ Interface de la classe <Collection> (fichier Collection.h) ------

#ifndef COLLECTION_H_
#define COLLECTION_H_

//--------------------------------------------------- Interfaces utilisées

//------------------------------------------------------------- Constantes

typedef enum codeRetour {OK, EMPTY, FULL, WARNING, ERROR} codeRetour;
//	OK: 		L'opération s'est déroulée correctement
//	EMPTY: 		La collection est vide
//	FULL:		La collection est pleine
//	WARNING:	Attention spécifique à l'opération
//	ERROR:		Erreur spécifique à l'opération

//------------------------------------------------------------------ Types

//------------------------------------------- Rôle de la classe Collection
//
// 	 La classe permet de créer et de gérer des collections.
// 	 Une collection est un ensemble d'éléments, ici des flotants.
//
// 	 Elle est caractérisée par sa capacité c'est à dire le nombre
// maximal de flotants qu'elle peut contenir ainsi que le nombre de
// flotants qu'elle contient.
// 	 Elle peut contenir des valeurs identiques.
//
// 	 Les éléments de la collection sont indicés: il est possible de repérer
// un élément à partir de son indice dans la collection.
// 	 Le premier élément a pour indice 0 et le dernier a pour indice le nombre
// d'éléments présents
// moins un.
//
// 	 Une collection est dite pleine si le nombre d'éléments est égale à la
// capacité maximale. Une collection est dite vide si le nombre d'éléments
// est nul.
//
// 	 Les méthodes de la classe sont:
//   - Display 			-> Afficher les éléments de la collection
// 	 - Add (élément) 	-> Ajouter un élément à la collection
//	 - Add (collection) -> Ajouter tous les éléments d'une autre collection
//							à la collection
//	 - Resize 			-> Redimensionner la collection : modifier la capacité
//							de la collection
//	 - Remove 			-> Supprimer un ou plusieurs éléments de la collection
//	 - Count 			-> Renvoyer le nombre d'éléments de la collection
//	 - Capacity 		-> Renvoyer la capacité de la collection
//	 - GetItem 			-> Accéder en lecture à un élément de la collection
//
// 	 Certaines méthodes renvoient un code de retour indiquant le succès de
// l'opération ou une erreur.
//
// 	 Ces codes de retour sont:
// - OK 		// L'opération s'est déroulée correctement
// - FULL 		// La collection est pleine
// - EMPTY 		// La collection est vide
// - ERROR		// Erreur spécifique à l'opération
// - WARNING	// Attention spécifique à l'opération
//
//------------------------------------------------------------------------

class Collection
{

//----------------------------------------------------------------- PUBLIC

	public:

//----------------------------------------------------- Methodes publiques

		void Display();
		// Mode d'emploi :	Affiche les éléments présents dans la collection
		//					Si la collection est vide
		//						-> le message collection vide est affiché
		//					Sinon
		//						-> les éléments et leurs indices sont affichés sur des lignes différentes
		// Contrat :
		//

		codeRetour Add(float newElement);
		// Mode d'emploi : 	Ajoute un élément à la collection
		//					Si la collection est pleine
		//						-> l'élément n'est pas ajouté
		//						-> la méthode retourne FULL
		//					Sinon
		//						-> l'élément est ajouté
		//						-> la méthode retourne OK
		//
		// 				   	Paramètre : newElement -> Element à ajouter
		//
		// Contrat :
		//

		codeRetour Add(Collection &newCollection);
		// Mode d'emploi : 	Ajoute tous les éléments d'une autre collection à la collection
		//					Si la collection est pleine
		//						-> sa capacité est modifiée pour pouvoir accueillir les éléments des deux collections
		//						-> les éléments de la nouvelle collection sont ajoutés à la collection
		//						-> la méthode retourne OK
		//					Sinon
		//						-> la capacité de la collection n'est pas modifiée
		//					    -> les éléments de la nouvelle collection sont ajoutés à la collection
		//						-> la méthode retourne OK
		//
		// 				   	Paramètre : newCollection -> Collection à ajouter
		//
		// Contrat :
		//

		codeRetour Resize(int newCollectionSize);
		// Mode d'emploi :	Augmente ou diminue la capacité de la collection
		//      		   	Si le nombre d'éléments présents dans la collection est supérieur à la nouvelle capacité
		//						-> La capacité de la collection est modifiée
		//						-> Les éléments dont l'indice est supérieur à la nouvelle capacité sont perdus
		//						-> La méthode retourne OK
		//					Sinon
		//						-> La capacité de la collection est modifiée
		//						-> Aucun élément n'est perdu
		//						-> La méthode retourne OK
		//
		//					Paramètre : newCollectionSize -> Nouvelle capacité de la collection
		//
		// Contrat : La nouvelle capacité de la collection est un entier naturel
		//

		codeRetour Remove(int elementArraySize, int *elementArray);
		// Mode d'emploi :	Supprime un ou plusieurs éléments de la collection en fonction de leur indice
		// 				  	Si la collection est vide
		//						-> Aucun élément n'est supprimé
		//						-> La capacité de la collection n'est pas modifiée
		//						-> La méthode retourne FULL
		//				   	Sinon si un des éléments à retirer n'est pas présent dans la collection
		//						-> Seuls les éléments présents dans la collection sont supprimés
		//						-> La capacité de la collection est égale au nombre d'éléments présents dans la collection après suppression
		//						-> La méthode retourne WARNING
		//					Sinon si
		//						-> L'élément est supprimé une seule fois
		//						-> La capacité de la collection est égale au nombre d'éléments présents dans la collection après suppression
		//						-> La méthode retourne WARNING
		//					Sinon
		//						-> Les éléments sont supprimés
		//						-> La capacité de la collection est égale au nombre d'éléments présents dans la collection après suppression
		//						-> La méthode retourne OK
		//
		//					Paramètres -> elementArray -> Pointeur sur le tableau contenant les indices des éléments à supprimer de la collection
		//							   -> elementArraySize -> Nombre d'éléments à supprimer
		// Contrat : Les indices sont des entiers naturels
		//			 Le nombre d'éléments à supprimer est un entier naturel

		int Count();
		// Mode d'emploi : Retourne le nombre d'éléments présents dans la collection
		//
		// Contrat :
		//

		int Capacity();
		// Mode d'emploi : Retourne la capacité maximale de la collection
		//
		// Contrat :
		//

		codeRetour GetItem(int index, float &element);
		// Mode d'emploie : Accède en lecture à un élément de la collection en fonction de son indice
		// 					Si l'élément n'est pas dans la collection
		//						-> La méthode retourne ERROR
		//					Sinon
		//						-> L'élément est récupéré dans la variable element
		//						-> La méthode retourne OK
		//
		//					Paramètres -> index -> Indice dans la collection de l'élément à lire
		//							   -> element -> Element lu
		//
		// Contrat : L'indice de l'élément à lire est un entier naturel
		//

//-------------------------------------------------- Surcharge d'opérateur

//-------------------------------------------- Constructeurs - destructeur

		Collection(int collectionSize);
		// Mode d'emploi : Crée une collection vide de capacité donnée
		//
		//				   Paramètre -> collectionSize -> Capacité de la collection à créer
		//
		// Contrat : la capacité de la collection est un entier naturel
		//

		Collection(int collectionSize, int elementArraySize, float *elementArray);
		// Mode d'emploi : Crée une collection initialisée avec des éléments donnés et de capacité donnée
		//
		//				   Paramètres -> collectionSize -> Capacité de la collection
		//							  -> elementArray -> Pointeur sur le tableau contenant les éléments à mettre dans la collection à sa création
		//							  -> elementArraySize -> Nombre d'élément à mettre dans la collection à sa création
		//
		// Contrat : Le tableau contenant des éléments à mettre dans la collection contient autant d'éléments que la valeur de elementArraySize
		//			 Le nombre d'éléments à mettre dans la collection est un entier naturel
		//

		~Collection();
		// Mode d'emploi : Détruit la collection
		//
		// Contrat :
		//


//------------------------------------------------------------------ PRIVE

	protected:

//----------------------------------------------------- Méthodes protégées

//----------------------------------------------------- Attributs protégés

		float* collectionArray;
		// Pointeur sur le tableau contenant les éléments de la collection

		int size;
		// Capacité de la collection

		int nbElements;
		// Nombre d'élements présents dans la collection

};

//------- Autres définitions dépendantes de <Collection> ------------------

#endif /* COLLECTION_H_ */
